/*
 * Copyright (c) 2023 iQi.Co.Ltd. All rights reserved.
 */
 
using System.Collections.Generic;
using NetProtocol.POD;
using NetProtocol.Enum;
using IQIGame.Onigao.Game;
using IQIGame.Onigao.GamePlay;
using IQIGame.Onigao.Framework;
using Cysharp.Threading.Tasks;
using System;
using static IQIGame.Onigao.Game.MessageWrapper;

namespace NetProtocol.Client {
	/// <summary>
	/// 玩家业务模块
	/// module : player
	/// </summary>
	public interface CNetPlayer : INetClientModule {
		
		public ISession GetSession();
	
		Dictionary<int, INetClientModule.Package2MessageWrapper> INetClientModule.GetModuleFunction()
        {
            MessageFunction changeNameResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<ChangeNameResultData>)wrapper;
                SC_changeNameResult(session, ref _wrapper.message);
                MessageWrapperPool<ChangeNameResultData>.Put(_wrapper);
            };
            MessageFunction changeDataResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<ChangeDataResultData>)wrapper;
                SC_changeDataResult(session, ref _wrapper.message);
                MessageWrapperPool<ChangeDataResultData>.Put(_wrapper);
            };
            MessageFunction getPlayerInfoResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<GetPlayerInfoResultData>)wrapper;
                SC_getPlayerInfoResult(session, ref _wrapper.message);
                MessageWrapperPool<GetPlayerInfoResultData>.Put(_wrapper);
            };
            MessageFunction useGiftCodeResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<UseGiftCodeResultData>)wrapper;
                SC_useGiftCodeResult(session, ref _wrapper.message);
                MessageWrapperPool<UseGiftCodeResultData>.Put(_wrapper);
            };
            MessageFunction changeKanbanResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<ChangeKanbanResultData>)wrapper;
                SC_changeKanbanResult(session, ref _wrapper.message);
                MessageWrapperPool<ChangeKanbanResultData>.Put(_wrapper);
            };
            MessageFunction triggerGuideResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<TriggerGuideResultData>)wrapper;
                SC_triggerGuideResult(session, ref _wrapper.message);
                MessageWrapperPool<TriggerGuideResultData>.Put(_wrapper);
            };
            MessageFunction refreshReadPointResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<RefreshReadPointResultData>)wrapper;
                SC_refreshReadPointResult(session, ref _wrapper.message);
                MessageWrapperPool<RefreshReadPointResultData>.Put(_wrapper);
            };
            MessageFunction saveSettingDataResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<SaveSettingDataResultData>)wrapper;
                SC_saveSettingDataResult(session, ref _wrapper.message);
                MessageWrapperPool<SaveSettingDataResultData>.Put(_wrapper);
            };
            MessageFunction updatePlayerInfo_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdatePlayerInfoData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_updatePlayerInfo, "Recv->" + _wrapper.message.ToString());
#endif
                SC_updatePlayerInfo(session, _wrapper.message.update);
                MessageWrapperPool<UpdatePlayerInfoData>.Put(_wrapper);
            };
            MessageFunction notifyFunctionTypeOpen_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyFunctionTypeOpenData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyFunctionTypeOpen, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyFunctionTypeOpen(session, _wrapper.message.functionTypeId);
                MessageWrapperPool<NotifyFunctionTypeOpenData>.Put(_wrapper);
            };
            MessageFunction notifyUnlockEvent_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyUnlockEventData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyUnlockEvent, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyUnlockEvent(session, _wrapper.message.eventCid);
                MessageWrapperPool<NotifyUnlockEventData>.Put(_wrapper);
            };
            MessageFunction notifyEnergyRecovery_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyEnergyRecoveryData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyEnergyRecovery, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyEnergyRecovery(session, _wrapper.message.energy, _wrapper.message.nextRecoveryEnergyTime);
                MessageWrapperPool<NotifyEnergyRecoveryData>.Put(_wrapper);
            };
            MessageFunction updatePlayerGlobalBuff_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdatePlayerGlobalBuffData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_updatePlayerGlobalBuff, "Recv->" + _wrapper.message.ToString());
#endif
                SC_updatePlayerGlobalBuff(session, _wrapper.message.globalBuffs);
                MessageWrapperPool<UpdatePlayerGlobalBuffData>.Put(_wrapper);
            };
            MessageFunction notifyUnLockAvatar_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyUnLockAvatarData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyUnLockAvatar, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyUnLockAvatar(session, _wrapper.message.avatarId, _wrapper.message.remove);
                MessageWrapperPool<NotifyUnLockAvatarData>.Put(_wrapper);
            };
            MessageFunction notifyReadPoint_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyReadPointData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyReadPoint, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyReadPoint(session, _wrapper.message.readPoint);
                MessageWrapperPool<NotifyReadPointData>.Put(_wrapper);
            };
            MessageFunction notifyUpdatePlayerParams_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyUpdatePlayerParamsData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyUpdatePlayerParams, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyUpdatePlayerParams(session, _wrapper.message.paramID, _wrapper.message.value);
                MessageWrapperPool<NotifyUpdatePlayerParamsData>.Put(_wrapper);
            };
            MessageFunction notifyEffectNotice_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyEffectNoticeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyEffectNotice, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyEffectNotice(session, _wrapper.message.effectType, _wrapper.message.effectParams, _wrapper.message.num);
                MessageWrapperPool<NotifyEffectNoticeData>.Put(_wrapper);
            };
            MessageFunction notifyDailyReset_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyDailyResetData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyDailyReset, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyDailyReset(session, _wrapper.message.dailyReset);
                MessageWrapperPool<NotifyDailyResetData>.Put(_wrapper);
            };
            MessageFunction notifyUnLockAvatarFrame_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyUnLockAvatarFrameData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyUnLockAvatarFrame, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyUnLockAvatarFrame(session, _wrapper.message.avatarFrame, _wrapper.message.remove);
                MessageWrapperPool<NotifyUnLockAvatarFrameData>.Put(_wrapper);
            };
            MessageFunction notifyUnLockTitle_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyUnLockTitleData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyUnLockTitle, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyUnLockTitle(session, _wrapper.message.title, _wrapper.message.remove);
                MessageWrapperPool<NotifyUnLockTitleData>.Put(_wrapper);
            };
            MessageFunction notifyExecution_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyExecutionData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyExecution, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyExecution(session, _wrapper.message.id);
                MessageWrapperPool<NotifyExecutionData>.Put(_wrapper);
            };
            MessageFunction notifyAvatarTimelimit_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyAvatarTimelimitData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyAvatarTimelimit, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyAvatarTimelimit(session, _wrapper.message.avatarTimelimit);
                MessageWrapperPool<NotifyAvatarTimelimitData>.Put(_wrapper);
            };
            MessageFunction notifyAvatarFrameTimelimit_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyAvatarFrameTimelimitData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyAvatarFrameTimelimit, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyAvatarFrameTimelimit(session, _wrapper.message.avatarFrameTimelimit);
                MessageWrapperPool<NotifyAvatarFrameTimelimitData>.Put(_wrapper);
            };
            MessageFunction notifyTitleTimelimit_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyTitleTimelimitData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_notifyTitleTimelimit, "Recv->" + _wrapper.message.ToString());
#endif
                SC_notifyTitleTimelimit(session, _wrapper.message.titleTimelimit);
                MessageWrapperPool<NotifyTitleTimelimitData>.Put(_wrapper);
            };
        
            Dictionary<int, INetClientModule.Package2MessageWrapper> retDic = new()
            {
                {NetMessageId.player_changeNameResult, (session, package) => {
                	var result = MessageWrapperPool<ChangeNameResultData>.Get();
                	result.Init(session, changeNameResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_changeDataResult, (session, package) => {
                	var result = MessageWrapperPool<ChangeDataResultData>.Get();
                	result.Init(session, changeDataResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_getPlayerInfoResult, (session, package) => {
                	var result = MessageWrapperPool<GetPlayerInfoResultData>.Get();
                	result.Init(session, getPlayerInfoResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_useGiftCodeResult, (session, package) => {
                	var result = MessageWrapperPool<UseGiftCodeResultData>.Get();
                	result.Init(session, useGiftCodeResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_changeKanbanResult, (session, package) => {
                	var result = MessageWrapperPool<ChangeKanbanResultData>.Get();
                	result.Init(session, changeKanbanResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_triggerGuideResult, (session, package) => {
                	var result = MessageWrapperPool<TriggerGuideResultData>.Get();
                	result.Init(session, triggerGuideResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_refreshReadPointResult, (session, package) => {
                	var result = MessageWrapperPool<RefreshReadPointResultData>.Get();
                	result.Init(session, refreshReadPointResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_saveSettingDataResult, (session, package) => {
                	var result = MessageWrapperPool<SaveSettingDataResultData>.Get();
                	result.Init(session, saveSettingDataResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_updatePlayerInfo, (session, package) => {
                	var result = MessageWrapperPool<UpdatePlayerInfoData>.Get();
                	result.Init(session, updatePlayerInfo_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyFunctionTypeOpen, (session, package) => {
                	var result = MessageWrapperPool<NotifyFunctionTypeOpenData>.Get();
                	result.Init(session, notifyFunctionTypeOpen_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyUnlockEvent, (session, package) => {
                	var result = MessageWrapperPool<NotifyUnlockEventData>.Get();
                	result.Init(session, notifyUnlockEvent_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyEnergyRecovery, (session, package) => {
                	var result = MessageWrapperPool<NotifyEnergyRecoveryData>.Get();
                	result.Init(session, notifyEnergyRecovery_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_updatePlayerGlobalBuff, (session, package) => {
                	var result = MessageWrapperPool<UpdatePlayerGlobalBuffData>.Get();
                	result.Init(session, updatePlayerGlobalBuff_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyUnLockAvatar, (session, package) => {
                	var result = MessageWrapperPool<NotifyUnLockAvatarData>.Get();
                	result.Init(session, notifyUnLockAvatar_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyReadPoint, (session, package) => {
                	var result = MessageWrapperPool<NotifyReadPointData>.Get();
                	result.Init(session, notifyReadPoint_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyUpdatePlayerParams, (session, package) => {
                	var result = MessageWrapperPool<NotifyUpdatePlayerParamsData>.Get();
                	result.Init(session, notifyUpdatePlayerParams_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyEffectNotice, (session, package) => {
                	var result = MessageWrapperPool<NotifyEffectNoticeData>.Get();
                	result.Init(session, notifyEffectNotice_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyDailyReset, (session, package) => {
                	var result = MessageWrapperPool<NotifyDailyResetData>.Get();
                	result.Init(session, notifyDailyReset_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyUnLockAvatarFrame, (session, package) => {
                	var result = MessageWrapperPool<NotifyUnLockAvatarFrameData>.Get();
                	result.Init(session, notifyUnLockAvatarFrame_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyUnLockTitle, (session, package) => {
                	var result = MessageWrapperPool<NotifyUnLockTitleData>.Get();
                	result.Init(session, notifyUnLockTitle_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyExecution, (session, package) => {
                	var result = MessageWrapperPool<NotifyExecutionData>.Get();
                	result.Init(session, notifyExecution_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyAvatarTimelimit, (session, package) => {
                	var result = MessageWrapperPool<NotifyAvatarTimelimitData>.Get();
                	result.Init(session, notifyAvatarTimelimit_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyAvatarFrameTimelimit, (session, package) => {
                	var result = MessageWrapperPool<NotifyAvatarFrameTimelimitData>.Get();
                	result.Init(session, notifyAvatarFrameTimelimit_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.player_notifyTitleTimelimit, (session, package) => {
                	var result = MessageWrapperPool<NotifyTitleTimelimitData>.Get();
                	result.Init(session, notifyTitleTimelimit_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
            };
            return retDic;
        }
#region Client-side Interface
		/// <summary>
        /// 
        /// </summary>
		public void SC_changeNameResult(ISession session, ref ChangeNameResultData message) 
		{
            _SC_changeNameResult(session, ref message);
		}
		
		public void _SC_changeNameResult(ISession session, ref ChangeNameResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_changeNameResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_changeNameResult, message.code);
			MsgAsyncAwaiter<ChangeNameResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_changeDataResult(ISession session, ref ChangeDataResultData message) 
		{
            _SC_changeDataResult(session, ref message);
		}
		
		public void _SC_changeDataResult(ISession session, ref ChangeDataResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_changeDataResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_changeDataResult, message.code);
			MsgAsyncAwaiter<ChangeDataResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_getPlayerInfoResult(ISession session, ref GetPlayerInfoResultData message) 
		{
            _SC_getPlayerInfoResult(session, ref message);
		}
		
		public void _SC_getPlayerInfoResult(ISession session, ref GetPlayerInfoResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_getPlayerInfoResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_getPlayerInfoResult, message.code);
			MsgAsyncAwaiter<GetPlayerInfoResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_useGiftCodeResult(ISession session, ref UseGiftCodeResultData message) 
		{
            _SC_useGiftCodeResult(session, ref message);
		}
		
		public void _SC_useGiftCodeResult(ISession session, ref UseGiftCodeResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_useGiftCodeResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_useGiftCodeResult, message.code);
			MsgAsyncAwaiter<UseGiftCodeResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_changeKanbanResult(ISession session, ref ChangeKanbanResultData message) 
		{
            _SC_changeKanbanResult(session, ref message);
		}
		
		public void _SC_changeKanbanResult(ISession session, ref ChangeKanbanResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_changeKanbanResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_changeKanbanResult, message.code);
			MsgAsyncAwaiter<ChangeKanbanResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_triggerGuideResult(ISession session, ref TriggerGuideResultData message) 
		{
            _SC_triggerGuideResult(session, ref message);
		}
		
		public void _SC_triggerGuideResult(ISession session, ref TriggerGuideResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_triggerGuideResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_triggerGuideResult, message.code);
			MsgAsyncAwaiter<TriggerGuideResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_refreshReadPointResult(ISession session, ref RefreshReadPointResultData message) 
		{
            _SC_refreshReadPointResult(session, ref message);
		}
		
		public void _SC_refreshReadPointResult(ISession session, ref RefreshReadPointResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_refreshReadPointResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_refreshReadPointResult, message.code);
			MsgAsyncAwaiter<RefreshReadPointResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_saveSettingDataResult(ISession session, ref SaveSettingDataResultData message) 
		{
            _SC_saveSettingDataResult(session, ref message);
		}
		
		public void _SC_saveSettingDataResult(ISession session, ref SaveSettingDataResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.player_saveSettingDataResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.player_saveSettingDataResult, message.code);
			MsgAsyncAwaiter<SaveSettingDataResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 角色信息更新消息
        /// </summary>
		protected void SC_updatePlayerInfo(ISession session, UpdatePlayerInfoPOD update);
		/// <summary>
        /// 通知功能开启
        /// </summary>
		protected void SC_notifyFunctionTypeOpen(ISession session, int functionTypeId);
		/// <summary>
        /// 通知事件解锁
        /// </summary>
		protected void SC_notifyUnlockEvent(ISession session, int eventCid);
		/// <summary>
        /// 通知罗盘能量恢复，recoveryEnergyTime=下次恢复时间戳
        /// </summary>
		protected void SC_notifyEnergyRecovery(ISession session, int energy, int nextRecoveryEnergyTime);
		/// <summary>
        /// 通知全局buff更新
        /// </summary>
		protected void SC_updatePlayerGlobalBuff(ISession session, List<GlobalBuffPOD> globalBuffs);
		/// <summary>
        ///  解锁头像
        /// </summary>
		protected void SC_notifyUnLockAvatar(ISession session, int avatarId, bool remove);
		/// <summary>
        ///  红点推送
        /// </summary>
		protected void SC_notifyReadPoint(ISession session, Dictionary<int, bool> readPoint);
		/// <summary>
        /// 更新玩家参数
        /// </summary>
		protected void SC_notifyUpdatePlayerParams(ISession session, int paramID, int value);
		/// <summary>
        /// 通知效果提示
        /// </summary>
		protected void SC_notifyEffectNotice(ISession session, int effectType, List<int> effectParams, int num);
		/// <summary>
        /// 通知每日重置
        /// </summary>
		protected void SC_notifyDailyReset(ISession session, DailyResetPOD dailyReset);
		/// <summary>
        ///  解锁头像框
        /// </summary>
		protected void SC_notifyUnLockAvatarFrame(ISession session, int avatarFrame, bool remove);
		/// <summary>
        ///  解锁称号
        /// </summary>
		protected void SC_notifyUnLockTitle(ISession session, int title, bool remove);
		/// <summary>
        /// 通知执行
        /// </summary>
		protected void SC_notifyExecution(ISession session, int id);
		/// <summary>
        /// 通知头像时限更新
        /// </summary>
		protected void SC_notifyAvatarTimelimit(ISession session, Dictionary<int, int> avatarTimelimit);
		/// <summary>
        /// 通知头像框时限更新
        /// </summary>
		protected void SC_notifyAvatarFrameTimelimit(ISession session, Dictionary<int, int> avatarFrameTimelimit);
		/// <summary>
        /// 通知称号时限更新
        /// </summary>
		protected void SC_notifyTitleTimelimit(ISession session, Dictionary<int, int> titleTimelimit);
#endregion
#region Server-side Interface
		/// <summary>
        ///  修改玩家名称
        /// </summary>
    	public UniTask<ChangeNameResultData> CS_changeName(string newName)
        {
            return _CS_changeName(newName);
        }
        
        public UniTask<ChangeNameResultData> _CS_changeName(string newName)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(ChangeNameResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_changeName, "Send->"+"Player.CS_changeName { "
				+ "newName="
				+ newName
				+" }");
#endif
        	UniTask<ChangeNameResultData> task = MsgAsyncAwaiter<ChangeNameResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_changeName(newName));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_changeNameResult);
			return task;
        }
		
		public static SendPackage Pack_for_changeName(string newName) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_changeName;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_string(newName);
			return si_p;
		}
		/// <summary>
        ///  修改个人资料
        /// </summary>
    	public UniTask<ChangeDataResultData> CS_changeData(ChangeDataType type, string content)
        {
            return _CS_changeData(type, content);
        }
        
        public UniTask<ChangeDataResultData> _CS_changeData(ChangeDataType type, string content)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(ChangeDataResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_changeData, "Send->"+"Player.CS_changeData { "
				+ "type="
				+ type
				+ ", content="
				+ content
				+" }");
#endif
        	UniTask<ChangeDataResultData> task = MsgAsyncAwaiter<ChangeDataResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_changeData(type, content));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_changeDataResult);
			return task;
        }
		
		public static SendPackage Pack_for_changeData(ChangeDataType type, string content) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_changeData;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_byte((sbyte)type);
			_out.Write_string(content);
			return si_p;
		}
		/// <summary>
        ///  得到玩家信息
        /// </summary>
    	public UniTask<GetPlayerInfoResultData> CS_getPlayerInfo(string targetServerId, long targetPid)
        {
            return _CS_getPlayerInfo(targetServerId, targetPid);
        }
        
        public UniTask<GetPlayerInfoResultData> _CS_getPlayerInfo(string targetServerId, long targetPid)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(GetPlayerInfoResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_getPlayerInfo, "Send->"+"Player.CS_getPlayerInfo { "
				+ "targetServerId="
				+ targetServerId
				+ ", targetPid="
				+ targetPid
				+" }");
#endif
        	UniTask<GetPlayerInfoResultData> task = MsgAsyncAwaiter<GetPlayerInfoResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_getPlayerInfo(targetServerId, targetPid));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_getPlayerInfoResult);
			return task;
        }
		
		public static SendPackage Pack_for_getPlayerInfo(string targetServerId, long targetPid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_getPlayerInfo;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_string(targetServerId);
			_out.Write_long(targetPid);
			return si_p;
		}
		/// <summary>
        ///  兑换码
        /// </summary>
    	public UniTask<UseGiftCodeResultData> CS_useGiftCode(string code)
        {
            return _CS_useGiftCode(code);
        }
        
        public UniTask<UseGiftCodeResultData> _CS_useGiftCode(string code)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(UseGiftCodeResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_useGiftCode, "Send->"+"Player.CS_useGiftCode { "
				+ "code="
				+ code
				+" }");
#endif
        	UniTask<UseGiftCodeResultData> task = MsgAsyncAwaiter<UseGiftCodeResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_useGiftCode(code));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_useGiftCodeResult);
			return task;
        }
		
		public static SendPackage Pack_for_useGiftCode(string code) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_useGiftCode;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_string(code);
			return si_p;
		}
		/// <summary>
        ///  改变看板娘
        /// </summary>
    	public UniTask<ChangeKanbanResultData> CS_changeKanban(int cid)
        {
            return _CS_changeKanban(cid);
        }
        
        public UniTask<ChangeKanbanResultData> _CS_changeKanban(int cid)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(ChangeKanbanResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_changeKanban, "Send->"+"Player.CS_changeKanban { "
				+ "cid="
				+ cid
				+" }");
#endif
        	UniTask<ChangeKanbanResultData> task = MsgAsyncAwaiter<ChangeKanbanResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_changeKanban(cid));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_changeKanbanResult);
			return task;
        }
		
		public static SendPackage Pack_for_changeKanban(int cid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_changeKanban;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(cid);
			return si_p;
		}
		/// <summary>
        ///  触发引导
        /// </summary>
    	public UniTask<TriggerGuideResultData> CS_triggerGuide(int id, int step, TriggerGuideType type)
        {
            return _CS_triggerGuide(id, step, type);
        }
        
        public UniTask<TriggerGuideResultData> _CS_triggerGuide(int id, int step, TriggerGuideType type)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(TriggerGuideResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_triggerGuide, "Send->"+"Player.CS_triggerGuide { "
				+ "id="
				+ id
				+ ", step="
				+ step
				+ ", type="
				+ type
				+" }");
#endif
        	UniTask<TriggerGuideResultData> task = MsgAsyncAwaiter<TriggerGuideResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_triggerGuide(id, step, type));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_triggerGuideResult);
			return task;
        }
		
		public static SendPackage Pack_for_triggerGuide(int id, int step, TriggerGuideType type) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_triggerGuide;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(id);
			_out.Write_int(step);
			_out.Write_byte((sbyte)type);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<RefreshReadPointResultData> CS_refreshReadPoint(int type)
        {
            return _CS_refreshReadPoint(type);
        }
        
        public UniTask<RefreshReadPointResultData> _CS_refreshReadPoint(int type)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(RefreshReadPointResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_refreshReadPoint, "Send->"+"Player.CS_refreshReadPoint { "
				+ "type="
				+ type
				+" }");
#endif
        	UniTask<RefreshReadPointResultData> task = MsgAsyncAwaiter<RefreshReadPointResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_refreshReadPoint(type));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_refreshReadPointResult);
			return task;
        }
		
		public static SendPackage Pack_for_refreshReadPoint(int type) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_refreshReadPoint;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(type);
			return si_p;
		}
		/// <summary>
        ///  保存设置数据
        /// </summary>
    	public UniTask<SaveSettingDataResultData> CS_saveSettingData(string key, string value)
        {
            return _CS_saveSettingData(key, value);
        }
        
        public UniTask<SaveSettingDataResultData> _CS_saveSettingData(string key, string value)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(SaveSettingDataResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_saveSettingData, "Send->"+"Player.CS_saveSettingData { "
				+ "key="
				+ key
				+ ", value="
				+ value
				+" }");
#endif
        	UniTask<SaveSettingDataResultData> task = MsgAsyncAwaiter<SaveSettingDataResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_saveSettingData(key, value));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.player_saveSettingDataResult);
			return task;
        }
		
		public static SendPackage Pack_for_saveSettingData(string key, string value) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_saveSettingData;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_string(key);
			_out.Write_string(value);
			return si_p;
		}
		/// <summary>
        /// 上报剧情完成
        /// </summary>
    	public bool CS_uploadStoryCompleted(GamePlayAreaType areaType, int storyCid) 
    	{
    		return _CS_uploadStoryCompleted(areaType, storyCid);
    	}
    	public bool _CS_uploadStoryCompleted(GamePlayAreaType areaType, int storyCid)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.player_uploadStoryCompleted, "Send->"+"Player.CS_uploadStoryCompleted { "
				+ "areaType="
				+ areaType
				+ ", storyCid="
				+ storyCid
				+" }");
#endif
        	return session.SendPack(Pack_for_uploadStoryCompleted(areaType, storyCid));
        }
		
		public static SendPackage Pack_for_uploadStoryCompleted(GamePlayAreaType areaType, int storyCid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.player_uploadStoryCompleted;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_byte((sbyte)areaType);
			_out.Write_int(storyCid);
			return si_p;
		}
#endregion
#region Messages
        public struct ChangeNameResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_changeNameResult;}
            
            public override string ToString()
            {
                return "Player.changeNameResult"+ ", code="+ code;
            }
        }
        public struct ChangeDataResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public ChangeDataType type;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                type = _in.HasRemaining() ? (ChangeDataType)_in.Read_byte() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_changeDataResult;}
            
            public override string ToString()
            {
                return "Player.changeDataResult"+ ", code="+ code+ ", type="+ type;
            }
        }
        public struct GetPlayerInfoResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public PlayerShowPOD playerShow;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                playerShow = _in.HasRemaining() ? _in.Read_pod<PlayerShowPOD>(PlayerShowPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_getPlayerInfoResult;}
            
            public override string ToString()
            {
                return "Player.getPlayerInfoResult"+ ", code="+ code+ ", playerShow="+ playerShow;
            }
        }
        public struct UseGiftCodeResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public List<ItemShowPOD> items;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                items = _in.HasRemaining() ? _in.Read_list_pod<ItemShowPOD>(ItemShowPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_useGiftCodeResult;}
            
            public override string ToString()
            {
                return "Player.useGiftCodeResult"+ ", code="+ code+ ", items="+ items.ToString<ItemShowPOD>();
            }
        }
        public struct ChangeKanbanResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_changeKanbanResult;}
            
            public override string ToString()
            {
                return "Player.changeKanbanResult"+ ", code="+ code;
            }
        }
        public struct TriggerGuideResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public int id;
	        public int step;
	        public TriggerGuideType type;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                id = _in.HasRemaining() ? _in.Read_int() : default;
                step = _in.HasRemaining() ? _in.Read_int() : default;
                type = _in.HasRemaining() ? (TriggerGuideType)_in.Read_byte() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_triggerGuideResult;}
            
            public override string ToString()
            {
                return "Player.triggerGuideResult"+ ", code="+ code+ ", id="+ id+ ", step="+ step+ ", type="+ type;
            }
        }
        public struct RefreshReadPointResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_refreshReadPointResult;}
            
            public override string ToString()
            {
                return "Player.refreshReadPointResult"+ ", code="+ code;
            }
        }
        public struct SaveSettingDataResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_saveSettingDataResult;}
            
            public override string ToString()
            {
                return "Player.saveSettingDataResult"+ ", code="+ code;
            }
        }
        public struct UpdatePlayerInfoData : IReceiveMessage {
	        public UpdatePlayerInfoPOD update;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                update = _in.HasRemaining() ? _in.Read_pod<UpdatePlayerInfoPOD>(UpdatePlayerInfoPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_updatePlayerInfo;}
            
            public override string ToString()
            {
                return "Player.updatePlayerInfo"+ ", update="+ update;
            }
        }
        public struct NotifyFunctionTypeOpenData : IReceiveMessage {
	        public int functionTypeId;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                functionTypeId = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyFunctionTypeOpen;}
            
            public override string ToString()
            {
                return "Player.notifyFunctionTypeOpen"+ ", functionTypeId="+ functionTypeId;
            }
        }
        public struct NotifyUnlockEventData : IReceiveMessage {
	        public int eventCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                eventCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyUnlockEvent;}
            
            public override string ToString()
            {
                return "Player.notifyUnlockEvent"+ ", eventCid="+ eventCid;
            }
        }
        public struct NotifyEnergyRecoveryData : IReceiveMessage {
	        public int energy;
	        public int nextRecoveryEnergyTime;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                energy = _in.HasRemaining() ? _in.Read_int() : default;
                nextRecoveryEnergyTime = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyEnergyRecovery;}
            
            public override string ToString()
            {
                return "Player.notifyEnergyRecovery"+ ", energy="+ energy+ ", nextRecoveryEnergyTime="+ nextRecoveryEnergyTime;
            }
        }
        public struct UpdatePlayerGlobalBuffData : IReceiveMessage {
	        public List<GlobalBuffPOD> globalBuffs;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                globalBuffs = _in.HasRemaining() ? _in.Read_list_pod<GlobalBuffPOD>(GlobalBuffPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_updatePlayerGlobalBuff;}
            
            public override string ToString()
            {
                return "Player.updatePlayerGlobalBuff"+ ", globalBuffs="+ globalBuffs.ToString<GlobalBuffPOD>();
            }
        }
        public struct NotifyUnLockAvatarData : IReceiveMessage {
	        public int avatarId;
	        public bool remove;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                avatarId = _in.HasRemaining() ? _in.Read_int() : default;
                remove = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyUnLockAvatar;}
            
            public override string ToString()
            {
                return "Player.notifyUnLockAvatar"+ ", avatarId="+ avatarId+ ", remove="+ remove;
            }
        }
        public struct NotifyReadPointData : IReceiveMessage {
	        public Dictionary<int, bool> readPoint;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                readPoint = _in.HasRemaining() ? _in.Read_map_int_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyReadPoint;}
            
            public override string ToString()
            {
                return "Player.notifyReadPoint"+ ", readPoint="+ readPoint.ToString<int, bool>();
            }
        }
        public struct NotifyUpdatePlayerParamsData : IReceiveMessage {
	        public int paramID;
	        public int value;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                paramID = _in.HasRemaining() ? _in.Read_int() : default;
                value = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyUpdatePlayerParams;}
            
            public override string ToString()
            {
                return "Player.notifyUpdatePlayerParams"+ ", paramID="+ paramID+ ", value="+ value;
            }
        }
        public struct NotifyEffectNoticeData : IReceiveMessage {
	        public int effectType;
	        public List<int> effectParams;
	        public int num;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                effectType = _in.HasRemaining() ? _in.Read_int() : default;
                effectParams = _in.HasRemaining() ? _in.Read_list_int() : default;
                num = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyEffectNotice;}
            
            public override string ToString()
            {
                return "Player.notifyEffectNotice"+ ", effectType="+ effectType+ ", effectParams="+ effectParams.ToString<int>()+ ", num="+ num;
            }
        }
        public struct NotifyDailyResetData : IReceiveMessage {
	        public DailyResetPOD dailyReset;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                dailyReset = _in.HasRemaining() ? _in.Read_pod<DailyResetPOD>(DailyResetPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyDailyReset;}
            
            public override string ToString()
            {
                return "Player.notifyDailyReset"+ ", dailyReset="+ dailyReset;
            }
        }
        public struct NotifyUnLockAvatarFrameData : IReceiveMessage {
	        public int avatarFrame;
	        public bool remove;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                avatarFrame = _in.HasRemaining() ? _in.Read_int() : default;
                remove = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyUnLockAvatarFrame;}
            
            public override string ToString()
            {
                return "Player.notifyUnLockAvatarFrame"+ ", avatarFrame="+ avatarFrame+ ", remove="+ remove;
            }
        }
        public struct NotifyUnLockTitleData : IReceiveMessage {
	        public int title;
	        public bool remove;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                title = _in.HasRemaining() ? _in.Read_int() : default;
                remove = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyUnLockTitle;}
            
            public override string ToString()
            {
                return "Player.notifyUnLockTitle"+ ", title="+ title+ ", remove="+ remove;
            }
        }
        public struct NotifyExecutionData : IReceiveMessage {
	        public int id;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                id = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyExecution;}
            
            public override string ToString()
            {
                return "Player.notifyExecution"+ ", id="+ id;
            }
        }
        public struct NotifyAvatarTimelimitData : IReceiveMessage {
	        public Dictionary<int, int> avatarTimelimit;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                avatarTimelimit = _in.HasRemaining() ? _in.Read_map_int_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyAvatarTimelimit;}
            
            public override string ToString()
            {
                return "Player.notifyAvatarTimelimit"+ ", avatarTimelimit="+ avatarTimelimit.ToString<int, int>();
            }
        }
        public struct NotifyAvatarFrameTimelimitData : IReceiveMessage {
	        public Dictionary<int, int> avatarFrameTimelimit;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                avatarFrameTimelimit = _in.HasRemaining() ? _in.Read_map_int_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyAvatarFrameTimelimit;}
            
            public override string ToString()
            {
                return "Player.notifyAvatarFrameTimelimit"+ ", avatarFrameTimelimit="+ avatarFrameTimelimit.ToString<int, int>();
            }
        }
        public struct NotifyTitleTimelimitData : IReceiveMessage {
	        public Dictionary<int, int> titleTimelimit;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                titleTimelimit = _in.HasRemaining() ? _in.Read_map_int_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.player_notifyTitleTimelimit;}
            
            public override string ToString()
            {
                return "Player.notifyTitleTimelimit"+ ", titleTimelimit="+ titleTimelimit.ToString<int, int>();
            }
        }
    }
#endregion
}